A Beginner's Experience with Vibe Coding - Claude Code on Desktop

Last December, while experimenting with Vibe Coding, I chose to start with Claude Code on desktop, using an old project to test it out. During my Vibe Coding practice, I didn't intervene too much because I wanted to see the extent of its capabilities. Furthermore, I only knew about Claude's 5-hour reset quota, but I didn't realize there was a hidden Weekly Active Compute Hours limit (Anthropic noted in an August 2025 notification that Pro users have approximately 40-80 hours of Sonnet 4 compute per week). Because Vibe Coding consumes tokens much faster than expected, I not only exhausted my quota early, but because the weekly quota is calculated on a "7-day rolling" basis, I was locked out for several days. Coupled with a temporary switch to evaluating GitHub Copilot, I didn't renew my subscription, so this test was never actually completed.

Since I am currently unable to access the system to take screenshots, this article serves as a text-based record of that experience.

What is Claude Code on Desktop?

In the November 25, 2025 update, Claude Desktop added a Code tab, an interface that allows you to run Claude Code directly within the desktop application. Users do not need to open a terminal; they simply click the tab, install the dependencies, and can start using it immediately.

Operation Mechanism

After using it, I found its isolation logic quite unique. When a repository is selected, it does not modify the original files directly. Instead, it creates a folder with the same name as the project under the .claude-worktrees directory in the user's home folder. It then generates a subfolder with a random name (containing a full copy of the project) and creates a Git branch with a random name inside it.

All modifications occur within this isolated environment and branch. This design ensures the safety of the original project and enables the possibility of handling multiple tasks in parallel (each session corresponds to a different isolated environment).

Practical Experience

The Huge Difference in Context Understanding

When using AI assistance (like ChatGPT) in the early days, I was often limited by the input caps of the UI. Although long-text and file uploads were supported later, there is still a massive difference in precision compared to the context gained by Vibe Coding's direct reading of the entire project.

In the past, because I was too lazy to code, I would write the logic and expected steps for Claude and ask it to generate the code for me to adjust. However, I often encountered output length limits that caused the code to be truncated. When asking it to "continue generating," the subsequent code sometimes wouldn't connect properly (this was especially severe in early ChatGPT). When the logic I needed to write was too extensive, it was easy to spend a lot of time organizing the code because the details from multiple outputs wouldn't align.

In Vibe Coding mode, the AI fully understands the project structure, and the generated code no longer has truncation issues. This is the biggest difference in experience compared to traditional conversational AI.

Full of Emotional Value

I have to say, Vibe Coding feels great to use. It's like a senior colleague with a stable temperament who can discuss things with you and help handle more tedious tasks. When I asked it to optimize code, it not only followed instructions obediently but also provided detailed explanations. Sometimes, when I wasted quota and asked, "Am I asking for too much?", it replied, "That is the hallmark of a good engineer." It provides plenty of emotional value.

Issues and Pitfalls Encountered

1. Conversation Sessions Cannot Be Resumed

This was the most serious issue I encountered. When there is no activity for too long, a 401 Unauthorized error appears when entering a message, meaning once the connection is lost, the old session can never be recovered. Even worse, if you open a new session, it forces the creation of a brand new random isolated environment in .claude-worktrees. This prevented me from continuing my previous work progress, resetting all context to zero, which I found most frustrating.

TIP

Regarding this issue, I later discovered an unofficial workaround. See: Solving the issue where Claude Code on desktop cannot resume conversation sessions

2. Logical Contradictions in Context Understanding

I have my own preferences for Commit Messages and Coding Style, so I wrote relevant documentation and asked it to read it, but the process did not go smoothly.

First, when a session was disconnected and reconnected, it often forgot the previous settings. I also asked if I needed to set up references to other Markdown files in CLAUDE.md. It confidently told me, "No, I will read all Markdown files when loading." But testing showed it didn't read them at all. When I questioned it, it changed its story, saying, "I only read CLAUDE.md when loading, but I read the Commit specification file when writing a commit."

Regardless of whether its mechanism is "read on load" or "read when writing a commit," since the final commits it produced did not comply with the specifications, both statements were hallucinations at the time. In the end, I had to explicitly write the specifications into CLAUDE.md for it to finally listen.

Regarding the placement of specification files, this sparked another thought. I originally preferred "modular" management of specifications—placing rule files in specific directories of the project and referencing them via links in CLAUDE.md to keep the configuration file clean, avoid overlap with README.md, and prevent inconsistency issues where every project has its own rules.

However, after discussing this with Gemini, I learned that such AI editors (like GitHub Copilot) usually only read specific configuration files by default (like CLAUDE.md or .github/copilot-instructions.md). The "links" inside are just plain text paths to the AI and do not automatically read the content of those files into the context.

Therefore, the strategy must be adjusted. Although building a "centralized specification library" as the single source of truth is still necessary, the application method must shift from "referencing files" to "direct insertion": when opening a new project, I select appropriate modules from the central library (e.g., Git specs, Vue specs) and "copy-paste" the content directly into the CLAUDE.md body. While this sacrifices conciseness, it ensures the AI reads the specifications 100% while maintaining consistency across projects.

Best Practices for CLAUDE.md Configuration

According to the Determine memory type documentation, it is recommended to manage context in a layered manner:

• Global Settings: ~/.claude/CLAUDE.md. All sessions on the computer will read these settings.
• Project Settings: CLAUDE.md or .claude/CLAUDE.md (recommended) in the project root directory. This is the primary setting for the project; it is recommended to store it in the .claude folder to keep the root directory clean.
• Modular Rules: .claude/rules/*.md. The "modular" management method mentioned earlier, splitting different specifications (e.g., git.md, vue.md) so Claude can read them as needed.
• Local Override: ./CLAUDE.local.md. Project-specific local rules; be sure to include it in .gitignore to avoid accidental commits.

Additionally, according to Claude Code: Best practices for agentic coding, we can define rules specific to a subdirectory (e.g., backend/CLAUDE.md). Claude Code has an intelligent reading mechanism; when the Agent involves files in that directory, it will automatically read and apply these local contexts, achieving more precise specification control.

3. Hallucinations and Incorrect Information

In addition to the file reading mechanism mentioned above, it also hallucinates when providing suggestions. For example, when I asked where to put the specification file, it suggested putting it in the .github folder. But as everyone knows, .github is usually for GitHub Actions or Issue Templates, not a standard place for documentation. This shows that developers still need to exercise judgment when relying on AI suggestions.

4. Clumsiness and Conflicts in Git Operations

When performing Git operations, Claude Code sometimes appears "too clever for its own good":

• Taking the long way around and being counterproductive: For tasks that could be easily solved with git rebase -i, it might take a long way around using other methods. When the result is not as expected, it automatically reverts and tries other methods. While the spirit is commendable, this mechanism doesn't always succeed and sometimes makes the Git graph even messier.
• Pitfalls of the snapshot mechanism: This is a common problem for all AI editors. It takes snapshots of files. If you manually intervene after it fails an operation (e.g., manually resolving a Git conflict), it might ignore your changes and overwrite them with its old snapshot.

WARNING

If you want it to perform Git operations, it is safer to provide the Commit Hash directly rather than vaguely describing "modify that commit."

5. Performance Lag

When operating the Desktop version, there is noticeable lag in the interface. Sometimes, because there was no response, I accidentally pressed Enter multiple times, and it ended up sending multiple messages. Since it outputs a large amount of text every time a message is sent, it is easy to miss this. This not only causes operational confusion but may also lead to unnecessary quota consumption.

Conclusion

Although the experience was forced to end due to quota issues, and there is still much room for improvement in Git operations and session management, this experience truly showed me the turning point in development paradigms.

AI tools are evolving extremely fast. Early on, Vibe Coding was just a vague concept; before you know it, it has gradually matured. Of course, I don't think all work is suitable for Claude Code. While I currently believe Claude is still the most suitable model for coding, every tool has its best use case, and the future of development should be "Multi-Model" collaboration.

For example, if applied to Claude Code, the division of labor might look like this:

• Commit Message: Leave it to other free or cheaper AIs; don't waste Claude's quota.
• Complex Git Operations (Rebase): To avoid breaking the graph, I feel more comfortable doing these dangerous operations manually.
• Claude Code: Discussions or development tasks that require deep understanding of the project.
• Gemini / Other Models: If it's just a general technical question or doesn't involve a lot of project context, I would ask Gemini instead of Claude. If using a Pro subscription, Claude Chat and Claude Code share the same quota.

However, I still need to spend time exploring how to find the best AI tool combination for myself based on the strengths and costs (Q.Q) of each model.

---

Change Log

• 2026-01-06 Initial document creation.
• 2026-01-07 Added official CLAUDE.md configuration best practices and context inheritance mechanism explanation.